# 数字类型

# 列表切片
# my_list = ['p','r','o','g','r','a','m','i','z']
# # 从第3元素至第5个元素
# print(my_list[2:5])
# # 从开始到第4个元素
# print(my_list[:-5])
# # 第6个元素至结束
# print(my_list[5:])
# # 元素开始到结束
# print(my_list[:])

# 列表的方法
# my_list = ['p','r','o','b','l','e','m']
# # 追加元素
# my_list.append('d')
# print(my_list) # 输出: ['p', 'r', 'o', 'b', 'l', 'e', 'm', 'd']
# # 插入元素
# my_list.insert(3, 'c')
# print(my_list) # 输出: ['p', 'r', 'o', 'c', 'b', 'l', 'e','m', 'd']
# # 删除元素
# my_list.remove('p')
# print(my_list) # 输出: ['r', 'o', 'c', 'b', 'l', 'e','m', 'd']
# # 排序
# my_list.sort()
# print(my_list) # 输出: ['b', 'c', 'd', 'e', 'l', 'm', 'o', 'r']
# # 反转
# my_list.reverse()
# print(my_list) # 输出: ['r', 'o', 'm', 'l', 'e', 'd', 'c', 'b']
# # 统计元素出现次数
# print(my_list.count('b')) # 输出: 1
# # 清空列表
# my_list.clear()
# print(my_list) # 输出: []
# # 复制列表
# my_list = ['p','r','o','b','l','e','m']
# my_list2 = my_list.copy()
# print(my_list2) # 输出: ['p', 'r', 'o', 'b', 'l', 'e','m']
# # 合并列表
# my_list = ['p','r','o','b','l','e','m']
# my_list2 = ['a','b','c','d']
# my_list.extend(my_list2) 
# print(my_list) # 输出: ['p', 'r', 'o', 'b', 'l', 'e','m', 'a', 'b', 'c', 'd']
# print(my_list + my_list2) # 输出: ['p', 'r', 'o', 'b', 'l', 'e','m', 'a', 'b', 'c', 'd', 'a', 'b', 'c', 'd']
# # 查找元素
# my_list = ['p','r','o','b','l','e','m']
# print(my_list.index('b')) # 输出: 3
# # 弹出元素
# my_list = ['p','r','o','b','l','e','m']
# print(my_list.pop()) # 输出: m 弹出最后一个元素


# 元组
# 元组是不可变的，不能修改元组的元素。如果元素本身是可变的数据类型（如列表），则可以更改其嵌套项目。
# 元组可以包含任何类型的元素，包括数字、字符串、列表、元组等。
# my_tuple = ("hello")
# print(type(my_tuple))  # <class 'str'>

# 创建一个只有一个元素的元组
# my_tuple = ("hello",)  
# print(type(my_tuple))  # <class 'tuple'> 

# 括号是可选的
# my_tuple = "hello",
# print(type(my_tuple))  # <class 'tuple'>

# my_tuple = ('p','r','o','g','r','a','m','i','z')
# # 从第3元素至第5个元素
# print(my_tuple[2:5])
# # 从开始到第4个元素
# print(my_tuple[:-5])
# # 第6个元素至结束
# print(my_tuple[5:])

# 如果元素本身是可变的数据类型（如列表），则可以更改其嵌套项目
# my_tuple = ('p','r','1','5', ['3', '4', 'ps'])
# my_tuple[4][1] = '12'
# print(my_tuple) # 输出: ('p', 'r', '1', '5', ['3', '12', 'ps'])

# my_tuple = ('1',2, '3', 4, '5', 6, 7, 8, 9, 10) # 元组可以被重置
# print(my_tuple) # 输出: ('1', 2, '3', 4, '5', 6, 7, 8, 9, 10)

#元组的方法
# print(my_tuple.count('5')) # 输出: 1 , 统计元素出现次数
# print(my_tuple.index('5')) # 输出: 4 , 查找元素
# del my_tuple # 删除元组

# 元组的优势
# 我们通常将元组用于异构（不同）数据类型，将列表用于同类（相似）数据类型。
# 由于元组是不可变的，因此遍历元组要比使用list更快。因此，性能略有提升。
# 包含不可变元素的元组可以用作字典的键。对于列表，这是不可能的。
# 如果您拥有不变的数据，则将其实现为元组将确保其保持写保护。

# 字符串
# 字符串是不可变的，不能修改字符串的元素。
# 字符串可以包含任何类型的元素，包括数字、字符串、列表、元组等。
# my_string = "hello"
# print(type(my_string))  # <class 'str'>

# # 字符串是不可变的，不能修改字符串的元素。
# # my_string[0] = 'j' # 抛出TypeError异常, 字符串是不可变的

# print("'he said 'hello''") # 输出: 'he said 'hello''
# print("he said 'hello'")
# print('he said "hello"')
# # print("he said "hello"") # 抛出SyntaxError异常, 字符串中不能包含双引号
# # print('He said, "What's there?"') # 抛出SyntaxError异常, 字符串中不能包含双引号
# print("He said, \"What's there?\"") # 输出: He said, "What's there?"
# print("He said, 'What's there?'") # 输出: He said, 'What's there?'

# # 字符串的方法 [https://www.cainiaojc.com/python/python-methods-string.html]
# my_string = "hello world"
# print(my_string.capitalize()) # 输出: Hello world, 首字母大写
# print(my_string.upper()) # 输出: HELLO WORLD, 全部大写
# print(my_string.lower()) # 输出: hello world, 全部小写
# print(my_string.title()) # 输出: Hello World, 每个单词的首字母大写
# print(my_string.swapcase()) # 输出: HELLO WORLD, 大写转换为小写，小写转换为大写
# print(my_string.replace("world", "python")) # 输出: hello python, 替换字符串中的指定子字符串
# print(my_string.count("l")) # 输出: 3, 统计字符串中指定子字符串出现的次数
# print(my_string.find("world")) # 输出: 6, 查找字符串中指定子字符串的位置，如果找不到则返回-1
# print(my_string.index("world")) # 输出: 6, 查找字符串中指定子字符串的位置，如果找不到则抛出ValueError异常
# print(my_string.isalpha()) # 输出: False, 判断字符串是否只包含字母
# print(my_string.isdigit()) # 输出: False, 判断字符串是否只包含数字
# print(my_string.isalnum()) # 输出: False, 判断字符串是否只包含字母和数字
# print(my_string.isspace()) # 输出: False, 判断字符串是否只包含空格
# print(my_string.startswith("hello")) # 输出: True, 判断字符串是否以指定子字符串开头
# print(my_string.endswith("world")) # 输出: True, 判断字符串是否以指定子字符串结尾
# print(my_string.split()) # 输出: ['hello', 'world'], 将字符串分割成一个列表，默认以空格分隔
# print(my_string.split("o")) # 输出: ['hell', ' w', 'rld'], 将字符串分割成一个列表，以指定字符分隔
# print(my_string.join(["hello", "world"])) # 输出: hellohello worldworld, 将列表中的元素连接成一个字符串，以指定字符分隔
# print(my_string.strip()) # 输出: hello world, 去除字符串两端的空格
# print(my_string.rstrip()) # 输出: hello world, 去除字符串右端的空格
# print(my_string.lstrip()) # 输出: hello world, 去除字符串左端的空格
# print(my_string.zfill(20)) # 输出: 0000000000hello world, 用0填充字符串，使其长度为指定长度
# my_string = "hello {0}, world {1}"
# print(my_string.format("python", 'build')) # 输出: hello python, world build, 格式化字符串，用指定的参数替换字符串中的占位符

# 集合
# 集合是无序的，不可重复的，不可变的，不能修改集合的元素（无序，所以索引没有用）, 但可以增删。
# 集合可以包含任何类型的元素，包括数字、字符串、列表、元组等。

# 创建一个集合, 增减元素
# my_set = {1, 2, 3, 'hello', 5, 2, (1, 3, 4)}
# print(my_set) # 输出: {1, 2, 3, 'hello', 5, (1, 3, 4)}
# my_set2 = set(['a', 'b', '1', 'd', 'a']) # 创建一个集合，元素可以是任何类型的
# print(my_set2) # 输出: {'a', 'd', 'b', '1'}
# my_set.add('world') # 添加元素
# print(my_set) # 输出: {1, 2, 3, 'hello', 5, 'world', (1, 3, 4)}
# my_set.update([1, 2, 3, 4, 5]) # 添加多个元素
# print(my_set) # 输出: {1, 2, 3, 4, 5, 'hello', 'world', (1, 3, 4)}
# my_set.remove('hello') # 删除元素
# print(my_set) # 输出: {1, 2, 3, 4, 5, 'world', (1, 3, 4)}
# my_set.discard('world') # 删除元素，如果元素不存在则不抛出异常
# print(my_set) # 输出: {1, 2, 3, 4, 5, (1, 3, 4)}
# my_set.pop() # 删除一个元素
# print(my_set) # 输出: {2, 3, 4, 5, (1, 3, 4)}

# 集合的方法，两个集合的运算 [https://www.cainiaojc.com/python/python-methods-set.html]
# my_set = {1, 2, 3, 'hello', 5, 2, (1, 3, 4)}
# print(my_set.copy()) # 输出: {1, 2, 3, 'hello', 5, (1, 3, 4)}
# print(my_set.clear()) # 输出: None, 清空集合
# print(my_set) # 输出: set()

# my_set = {1, 2, 3, 'hello', 5, 2, (1, 3, 4)}
# my_set2 = {1, 2, 3, 'world', 7, 2, (1, 5, 4)}

# print(my_set.difference(my_set2)) # 输出: {'hello', 5, (1, 3, 4)} 求两个集合的差集
# print(my_set - my_set2) # 输出: {'hello', 5, (1, 3, 4)} 求两个集合的差集

# print(my_set.intersection(my_set2)) # 输出: None, 从该集合中删除另一个集合的所有元素
# print(my_set & my_set2) # 输出: {1, 2, 3, (1, 3, 4)} 求两个集合的交集

# print(my_set.union(my_set2)) # 输出: {1, 2, 3, 'hello', 5, 'world', 7, (1, 3, 4), (1, 5, 4)} 求两个集合的并集
# print(my_set | my_set2) # 输出: {1, 2, 3, 'hello', 5, 'world', 7, (1, 3, 4), (1, 5, 4)} 求两个集合的并集

# print(my_set.symmetric_difference(my_set2)) # 输出: {'hello', 5, 'world', 7, (1, 3, 4), (1, 5, 4)} 求两个集合的对称差集
# print(my_set ^ my_set2) # 输出: {'hello', 5, 'world', 7, (1, 3, 4), (1, 5, 4)} 求两个集合的对称差集


# print(my_set.difference_update(my_set2)) # 输出: None, 从该集合中删除另一个集合的所有元素
# print(my_set) # 输出: {5, (1, 3, 4), 'hello'}
# print(my_set.intersection(my_set2)) # 输出: {1, 2, 3}, 求两个集合的交集

# 字典
# 字典是无序的集合，特别的是它可以有键值对
# 空字典
# my_dict = {}

# # 带有整数键的字典
# my_dict = {1: 'apple', 2: 'ball'}

# # 混合键字典
# my_dict = {'name': 'John', 1: [2, 4, 3]}

# # 使用 dict()
# my_dict = dict({1:'apple', 2:'ball'})

# # 将每个项作为一对的序列
# my_dict = dict([(1,'apple'), (2,'ball')])
# print(my_dict) # 输出: {1: 'apple', 2: 'ball'}


# 字典的方法
# my_dict = {1: 'apple', 2: 'ball'}
# print(my_dict.get(1)) # 输出: apple, 获取指定键的值，如果键不存在则返回None
# print(my_dict.get(3, 'Not Found')) # 输出: Not Found, 获取指定键的值，如果键不存在则返回指定值
# print(my_dict.keys()) # 输出: dict_keys([1, 2]), 获取字典中的所有键
# print(my_dict.values()) # 输出: dict_values(['apple', 'ball']), 获取字典中的所有值
# print(my_dict.items()) # 输出: dict_items([(1, 'apple'), (2, 'ball')]), 获取字典中的所有键值对
# print(my_dict.pop(1)) # 输出: apple, 删除指定键的值，如果键不存在则抛出KeyError异常
# print(my_dict) # 输出: {2: 'ball'}
# print(my_dict.popitem()) # 输出: (2, 'ball'), 删除字典中的最后一个键值对，并返回该键值对
# print(my_dict) # 输出: {}